// 处理cdatas数据(一种情况)
import { useAnalysetStore } from "@/store";

const analyseStatusPage = useAnalysetStore();

export function transformData(inputArray) {
  return inputArray.map((item) => {
    // 查找包含“测定结果”的键
    const cgjgKey = Object.keys(item).find((key) => key.includes("测定结果"));

    return {
      sample_sn: String(item["样品编号"] ?? item["样品唯一性标识"] ?? ""), // 兜底为空字符串
      type: String(item["类型"] || ""),
      test_parms: analyseStatusPage.waterForm.tableItem.test_parms,
      cdjg: String(item["最终结果"] ?? (cgjgKey ? item[cgjgKey] : "")), // 先取"最终结果"，否则取找到的"测定结果(单位)"
    };
  });
}

// 提取浓度单位的cdatas
export function transCdata(inputArray) {
  return inputArray.map((item) => {
    // 提取 "样品浓度(XXX)" 里的 XXX
    let dw = "";
    const ndKey = Object.keys(item).find((key) => key.includes("样品浓度")); // 动态匹配 "样品浓度"

    if (ndKey) {
      const match = ndKey.match(/\((.*?)\)/); // 提取括号内的内容
      dw = match ? match[1] : ""; // 如果匹配成功，取括号内的内容，否则为空
    }

    return {
      sample_sn: String(item["样品编号"] ?? item["样品唯一性标识"] ?? ""), // 兜底为空字符串
      type: String(item["类型"] || ""),
      cdjg: String(item["最终结果"] ?? item["测定结果"] ?? ""), // 先取"最终结果"，否则取"测定结果"
      dw: dw, // 存储括号内的内容
    };
  });
}

//处理插件表头是一行，不带合并单元格
export function processTableData(data) {
  if (!data || data.length < 2) {
    return [];
  }
  // 提取表头
  const headers = data[0].map((item) => item.field || "");
  console.log(headers, "headers");
  // 处理数据行
  const result = [];
  for (let i = 1; i < data.length; i++) {
    // 遍历每一行数据
    const values = data[i].map((item) => item.field ?? null);
    const rowObject = {};

    headers.forEach((header, index) => {
      if (header.trim()) {
        rowObject[header] = values[index] ?? null;
      }
    });

    result.push(rowObject);
  }
  return result;
}

// 处理具有合并表格的数据，不包括里面又元素、检出限这种
export function processData(data) {
  console.log(123444);
  if (!data || data.length < 2) {
    return [];
  }

  // 提取表头字段
  const headers = [];
  console.log(data[0], "data[0]");
  for (let i = 0; i < data[0].length; i++) {
    const field1 = data[0][i]?.field || ""; // 第一行的字段
    const field2 = data[1][i]?.field || ""; // 第二行的字段
    console.log(field1, field2, "field");
    // 优先使用第二行字段，如果为空则使用第一行字段
    const header = field1 === "默认字段" || field1 === "" ? field2 : field1;

    // 跳过无效字段
    if (header !== "默认字段" && header.trim() !== "") {
      headers.push(header);
    }
  }

  // 处理数据部分
  const result = data.slice(2).map((row) => {
    const rowObject = {};
    headers.forEach((header, index) => {
      const cell = row[index];
      rowObject[header] = cell?.field ?? null; // 如果没有值，则默认 null
    });
    return rowObject;
  });

  // 过滤掉空行（所有字段均为 null 的行）
  return result.filter((row) =>
    Object.values(row).some((value) => value !== null)
  );
}

// cdata里面排除编号为null或者为空字符串的
export const removeNullSampleSN = (data) => {
  return data.filter(
    (item) =>
      item.sample_sn !== null &&
      item.sample_sn !== "" &&
      item.sample_sn !== undefined
  );
};

// cdata里面排除普通样并且排除编号为null的
export const filterValidSamples = (data, targetType = "普通样") => {
  return data.filter(
    (item) =>
      item.sample_sn !== null &&
      item.sample_sn !== "" &&
      item.sample_sn !== undefined &&
      item.type === targetType
  );
};

// adata里面排除编号为null或者为空字符串的
export function filterValidSampleAdatas(data) {
  return data.filter((item) => item["样品编号"] !== null);
}

//处理一元一次方程公式
export function linearRegression(x, y) {
  if (x.length !== y.length || x.length === 0) {
    throw new Error("x 和 y 数组长度必须相等且非空");
  }

  // 计算均值
  const xMean = x.reduce((sum, val) => sum + val, 0) / x.length;
  const yMean = y.reduce((sum, val) => sum + val, 0) / y.length;

  // 计算斜率 m 和截距 b
  let numerator = 0; // 分子
  let denominator = 0; // 分母

  for (let i = 0; i < x.length; i++) {
    numerator += (x[i] - xMean) * (y[i] - yMean);
    denominator += (x[i] - xMean) ** 2;
  }

  const m = numerator / denominator; // 斜率
  const b = yMean - m * xMean; // 截距

  // 计算相关性系数 R²
  let ssTotal = 0; // 总平方和
  let ssResidual = 0; // 残差平方和
  let ssRegression = 0; // 回归平方和

  for (let i = 0; i < x.length; i++) {
    const yPred = m * x[i] + b; // 预测值
    ssTotal += (y[i] - yMean) ** 2;
    ssResidual += (y[i] - yPred) ** 2;
    ssRegression += (yPred - yMean) ** 2;
  }

  const rSquared = ssRegression / ssTotal; // R²
  let r = Math.sqrt(Math.abs(rSquared)); // 计算 r

  // 根据斜率方向调整 r 的正负号
  if (m < 0) {
    r = -r;
  }

  // 返回结果（保留小数点后 4 位）
  return {
    slope: parseFloat(m.toFixed(4)), // 斜率
    intercept: parseFloat(b.toFixed(4)), // 截距
    rSquared: parseFloat(rSquared.toFixed(4)), // R²
    correlation: Math.floor(r * 10000) / 10000, // r（相关系数）
  };
}

// 处理pdf数据
// 处理A面的数据，如果样品编号超出26条就会多生成一张A面数据（仅限没有做特殊处理的adatas数据）
export function splitDataIntoPages(data, pageSize = 26) {
  let pages = [];
  let totalPages = Math.ceil(data.length / pageSize);
  for (let i = 0; i < totalPages; i++) {
    let startIdx = i * pageSize;
    let endIdx = startIdx + pageSize;
    // 截取当前页数据并剔除 "类型" 和 "测定结果" 字段
    let pageData = data.slice(startIdx, endIdx).map((item) => {
      let filteredItem = {};
      Object.keys(item).forEach((key) => {
        if (key !== "类型" && key.trim() !== "测定结果") {
          filteredItem[key] = item[key];
        }
      });
      return filteredItem;
    });
    // 确保每页有 26 条数据，不足时补齐
    while (pageData.length < pageSize) {
      let emptyRow = {};
      Object.keys(pageData[0]).forEach((key) => {
        emptyRow[key] = null;
      });
      pageData.push(emptyRow);
    }
    pages.push(pageData);
  }
  return pages;
}

// 处理表格头部数据，类似只有一行表头的数据可以调用
export function getHeaders(data, length) {
  // 获取字段名并排除 "类型" 和 "测定结果"
  const filteredKeys = Object.keys(data[0]).filter((key) => {
    return key !== "类型" && key.trim() != "测定结果";
  });
  return filteredKeys;
}

// 处理筛选平行样编号

// 处理筛选质控样编号并提取括号中的内容
export function zkylSamples(data) {
  // 筛选出类型为 "质控样" 的数据
  const filteredData = data.filter((item) => item.类型 === "质控样");

  const updatedData = filteredData.map((item) => {
    // 使用正则表达式提取样品编号中的括号里的内容
    const sampleNumber = item["样品编号"];
    const extractedContent = sampleNumber.match(/\((.*?)\)/); // 提取括号中的内容

    // 获取所有键名包含"测定结果"的值
    const resultKeys = Object.keys(item).filter((key) =>
      key.includes("测定结果")
    );
    const finalResult = resultKeys.map((key) => item[key]).filter(Boolean); // 过滤掉无效值

    return {
      type: item["类型"],
      finalResult: finalResult,
      extractedContent: extractedContent ? extractedContent[1] : null, // 如果找到括号内容则返回，否则返回 null
    };
  });

  return updatedData;
}

// 处理筛选空白样编号
export function kbylSamples(data) {
  // 筛选出类型为 "平行样" 的数据
  const filteredData = data.filter((item) => item.类型 === "空白样");

  const updatedData = filteredData.map((item) => {
    // 获取所有键名包含"测定结果"的值
    const resultKeys = Object.keys(item).filter((key) =>
      key.includes("测定结果")
    );
    const finalResult = resultKeys.map((key) => item[key]).filter(Boolean); // 过滤掉无效值

    return {
      sampleNumber: item["样品编号"],
      type: item["类型"],
      hfz: item["毫伏值(mV)"] || item["吸光度"], // 获取“毫伏值”或“吸光度”
      finalResult: finalResult, // 优先返回“测定结果”，没有的话返回“最终结果”
    };
  });
  return updatedData;
}

// 处理筛选空白样编号
export function qxylSamples(data) {
  // 筛选出类型为 "平行样" 的数据
  const filteredData = data.filter((item) => item.类型 === "校核点");

  const updatedData = filteredData.map((item) => {
    // 获取所有键名包含"测定结果"的值
    const resultKeys = Object.keys(item).filter((key) =>
      key.includes("测定结果")
    );

    // 获取这些键对应的所有值
    const finalResult = resultKeys.map((key) => item[key]).filter(Boolean); // 过滤掉无效值

    return {
      sampleNumber: item["样品编号"],
      type: item["类型"],
      finalResult: finalResult,
    };
  });
  return updatedData;
}

// 处理筛选空白样编号
export function jbylSamples(data) {
  // 筛选出类型为 "加标样" 的数据
  const filteredData = data.filter((item) => item.类型 === "加标样");

  const updatedData = filteredData.map((item) => {
    // 获取所有键名包含"测定结果"的值
    const resultKeys = Object.keys(item).filter((key) =>
      key.includes("测定结果")
    );

    // 获取这些键对应的所有值
    const finalResult = resultKeys.map((key) => item[key]).filter(Boolean); // 过滤掉无效值

    return {
      sampleNumber: item["样品编号"],
      type: item["类型"],
      finalResult: finalResult,
    };
  });
  return updatedData;
}
